home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / message.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  37.8 KB  |  1,335 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 25
  2. /* Copyright (c) 1990-1992 by the University of Illinois Board of Trustees */
  3. #pragma load EUDORA_LOAD
  4. #pragma segment Message
  5. TEHandle GetMessText(MessType **messH);
  6. int AppendMessage(TOCType **fromTocH,int fromN,TOCType **toTocH,Boolean copy);
  7. int MessErr;
  8. int FindAndCopyHeader(MessType **origMH,MessType **newMH,UPtr fromHead,short toHead);
  9. int TextFindAndCopyHeader(UPtr body,long size,MessType **newMH,UPtr fromHead,short toHead);
  10. UPtr FindHeaderString(UPtr text,UPtr headerName,long *size);
  11. FixMessTE(MessType **messH,short whichTXE,short oldNl);
  12. void WeedHeaders(UHandle buffer,long *weeded,short toWeed);
  13. MyWindowPtr OpenMessage(TOCType **tocH,int sumNum,MyWindowPtr win, Boolean showIt);
  14. void RemoveSelf(MessHandle messH,short head);
  15. #define HeaderName(num) (GetRString(scratch,HEADER_STRN+num),TrimWhite(scratch),scratch)
  16. void FindFrom(UPtr who, MessHandle messH);
  17. void Attribute(short attrId,MessHandle origMessH,MessHandle newMessH,Boolean atEnd);
  18. void XferCustomTable(MessHandle origMessH,MessHandle newMessH);
  19. /************************************************************************
  20.  * GetAMessage - grab a message
  21.  ************************************************************************/
  22. MyWindowPtr GetAMessage(TOCType **tocH,int sumNum,MyWindowPtr win, Boolean showIt)
  23. {
  24.     MessHandle messH;
  25. #ifdef DEBUG
  26.     if (BUG6) DebugStr("\p;hc;g");
  27. #endif
  28.     if (!tocH || (*tocH)->count<=sumNum) return(nil);
  29.     if (messH = (*tocH)->sums[sumNum].messH)
  30.     {
  31.         if (showIt)
  32.         {
  33.             if (!(*messH)->win->qWindow.visible)
  34.                 ShowMyWindow((*messH)->win);
  35.             SelectWindow((*messH)->win);
  36.         }
  37.         UsingWindow((*messH)->win);
  38.         return((*messH)->win);
  39.     }
  40.     else if ((*tocH)->which==OUT)
  41.         return(OpenComp(tocH,sumNum,win,showIt));
  42.     else
  43.         return(OpenMessage(tocH,sumNum,win,showIt));
  44. }
  45.  
  46. /**********************************************************************
  47.  * OpenMessage - open a message in its own window
  48.  **********************************************************************/
  49. MyWindowPtr OpenMessage(TOCType **tocH,int sumNum,MyWindowPtr win, Boolean showIt)
  50. {
  51.     Str255 title;
  52.     MessType **messH;
  53.     Boolean turvy = showIt && (CurrentModifiers()&optionKey)!=0;
  54.     TEHandle teh;
  55.  
  56.     CycleBalls();
  57.     if ((*tocH)->sums[sumNum].length > 32765)
  58.     {
  59.         WarnUser(TE_TOO_MUCH,(*tocH)->sums[sumNum].length);
  60.         return(nil);
  61.     }
  62.     
  63.     if ((messH = (MessType **)NewZHandle(sizeof(MessType)))==nil)
  64.         return(nil);
  65.         
  66.     win = GetNewMyWindow(MESSAGE_WIND,win,InFront,False,False);
  67.     if (!win)
  68.     {
  69.         DisposHandle(messH);
  70.         return(nil);
  71.     }
  72.     ((WindowPeek)win)->windowKind = MESS_WIN;
  73.  
  74.     (*tocH)->sums[sumNum].messH = messH;
  75.     (*messH)->win = win;
  76.     (*messH)->sumNum = sumNum;
  77.     (*messH)->tocH = tocH;
  78.     /* apply FLAG_OUT ex post facto */
  79.     if ((*tocH)->sums[sumNum].state==SENT || (*tocH)->sums[sumNum].state==UNSENT)
  80.         (*tocH)->sums[sumNum].flags |= FLAG_OUT;
  81.     
  82.     ((WindowPeek)win)->refCon = (long)messH;
  83.     win->close = MessClose;
  84.     win->menu = MessMenu;
  85.     win->gonnaShow = MessGonnaShow;
  86.     win->position = MessagePosition;
  87.     win->cursor = MessCursor;
  88.     win->button = CompButton;    /* it will do */
  89.     win->app1 = MessApp1;
  90.     LL_Push(MessList,messH);
  91.  
  92.     if (turvy)
  93.         ChangeStrn(PREF_STRN,PREF_SHOW_ALL,PrefIsSet(PREF_SHOW_ALL)?"\pn":"\py");
  94.     teh = GetMessText(messH);
  95.     win->ste = NewSTE(win,&win->contR,False,True,False);
  96.     if (turvy)
  97.         ChangeStrn(PREF_STRN,PREF_SHOW_ALL,PrefIsSet(PREF_SHOW_ALL)?"\pn":"\py");
  98.     
  99.     if (!teh || !win->ste)
  100.     {
  101.         if (teh) TEDispose(teh);
  102.         CloseMyWindow(win);
  103.         return(nil);
  104.     }
  105.     else
  106.     {
  107.         STEInstallText((*teh)->hText,win->ste);
  108.         (*(*(STEHandle)win->ste)->te)->teLength = (*teh)->teLength;
  109.         LDRef(teh)->hText = NuHandle(0);
  110.         (*teh)->teLength = 0;
  111.         TEDispose(teh);
  112.         (*messH)->txes[BODY] = (*(STEHandle)win->ste)->te;
  113.         (*messH)->stes[0] = win->ste;
  114.         (*(*messH)->stes[0])->dontFrame = True;
  115.         (*(*messH)->stes[0])->growBox = True;
  116.     }
  117.     MakeMessTitle(title,tocH,sumNum);
  118.     SetWTitle(win,title);
  119.     if (showIt)
  120.         ShowMyWindow(win);
  121.     return(win);
  122. }
  123.  
  124. /**********************************************************************
  125.  * MakeMessTitle - make a reasonable message title from a summary
  126.  **********************************************************************/
  127. void MakeMessTitle(UPtr title,TOCType **tocH,int sumNum)
  128. {
  129.     Str63 from, date, mailbox, subject;
  130.     Str63 pattern;
  131.     
  132.     PCopy(from,(*tocH)->sums[sumNum].from);
  133.     if (*from >    (*tocH)->sums[sumNum].fromTrunc)
  134.     {
  135.         *from =    MAX(1,(*tocH)->sums[sumNum].fromTrunc);
  136.         from[*from] = '…';
  137.     }
  138.     
  139.     PCopy(date,(*tocH)->sums[sumNum].date);
  140.     if (*date >    (*tocH)->sums[sumNum].dateTrunc)
  141.     {
  142.         *date =    MAX(1,(*tocH)->sums[sumNum].dateTrunc);
  143.         date[*date] = '…';
  144.     }
  145.     
  146.     PCopy(mailbox,(*tocH)->name);
  147.     PCopy(subject,(*tocH)->sums[sumNum].subj);
  148.     
  149.     utl_PlugParams(GetRString(pattern,MESS_TITLE_PLUG),title,mailbox,from,date,subject);
  150. }
  151.         
  152. /**********************************************************************
  153.  * GetMessText - put the text of a message into a window's txe record
  154.  **********************************************************************/
  155. TEHandle GetMessText(MessType **messH)
  156. {
  157.     MyWindowPtr win = (*messH)->win;
  158.     TOCType **tocH = (*messH)->tocH;
  159.     int sumNum = (*messH)->sumNum;
  160.     UHandle buffer = nil;
  161.     TEHandle teh = nil;
  162.     Rect dRect;
  163.     long weeded;
  164.     short tableId;
  165.     Handle table;
  166.     
  167.     /*
  168.      * allocate space for the text
  169.      */
  170.     if ((buffer=NuHandle((*tocH)->sums[sumNum].length))==nil)
  171.     {
  172.         WarnUser(NO_MESS_BUF,MemError());
  173.         return(nil);
  174.     }
  175.     
  176.     /*
  177.      * read it
  178.      */
  179.     LDRef(buffer);
  180.     if (MessErr=ReadMessage(tocH,sumNum,*buffer))
  181.         goto failure;
  182.     UL(buffer);
  183.     
  184.     /*
  185.      * now, set up the TERec
  186.      */
  187.     dRect = win->contR;
  188.     InsetRect(&dRect,4,0);
  189.     if ((teh=TENew(&dRect,&win->contR))==nil)
  190.     {
  191.         WarnUser(MESS_TE,MemError());
  192.         goto failure;
  193.     }
  194.     
  195.     /*
  196.      * weed headers?
  197.      */
  198.     if (!PrefIsSet(PREF_SHOW_ALL))
  199.     {
  200.         WeedHeaders(buffer,&weeded,BADHEAD_STRN);
  201.         (*messH)->weeded = weeded;
  202.     }
  203.     else
  204.         (*messH)->weeded = 0;
  205.     WeedHeaders(buffer,&weeded,FROM_STRN);
  206.     (*messH)->weeded += weeded;
  207.     
  208.     /*
  209.      * translate?
  210.      */
  211.     tableId = (*tocH)->sums[sumNum].tableId;
  212.     if (tableId==DEFAULT_TABLE) tableId = GetRLong(PREF_STRN+PREF_IN_XLATE);
  213.     if (tableId!=NO_TABLE && (table=GetResource('taBL',tableId)))
  214.     {
  215.         Byte *p,*end,*t;
  216.         long size = GetHandleSize(buffer);
  217.         end = *buffer+size;
  218.         t = *table;
  219.         for (p=*buffer;p<end;p++) *p = t[*p];
  220.     }
  221.     
  222.     /*
  223.      * put in the text...
  224.      */
  225.     DisposHandle((*teh)->hText);
  226.     (*teh)->hText = buffer;
  227.     (*teh)->teLength = GetHandleSize(buffer);
  228.  
  229.  
  230.     win->ro = True;
  231.     return(teh);
  232.     
  233. failure:
  234.     if (buffer) DisposHandle(buffer);
  235.     if (teh) TEDispose(teh);
  236.     return(nil);
  237. }
  238.  
  239. /**********************************************************************
  240.  * ReadMessage - read a given message into a preallocated buffer
  241.  **********************************************************************/
  242. int ReadMessage(TOCType **tocH,int sumNum,UPtr buffer)
  243. {
  244.     long count;
  245.     Str255 name;
  246.     
  247.     BlockMove((*tocH)->name,name,(*(*tocH)->name)+1);
  248.     count = (*tocH)->sums[sumNum].length;
  249.  
  250.     if (!(MessErr=BoxFOpen(tocH)))
  251.       if ((MessErr=SetFPos((*tocH)->refN,fsFromStart,
  252.                                                (*tocH)->sums[sumNum].offset)) ||
  253.               (MessErr=FSRead((*tocH)->refN,&count,buffer)))
  254.             FileSystemError(READ_MBOX,name,MessErr);
  255.  
  256.     return(MessErr);
  257. }
  258.  
  259. /**********************************************************************
  260.  * MoveMessage - transfer a message from one box to another
  261.  * called when the transfer menu is invoked with a message frontmost
  262.  **********************************************************************/
  263. int MoveMessage(TOCType **tocH,int sumNum,long dirId,UPtr toWhich,Boolean copy)
  264. {
  265.     TOCType **toTocH;
  266.  
  267.     CycleBalls();
  268.  
  269.     if ((toTocH = TOCByName(dirId,toWhich))==nil)
  270.         return(1);
  271.         
  272.     CycleBalls();
  273.     MessErr=AppendMessage(tocH,sumNum,toTocH,copy);
  274.     if (MessErr) return(MessErr);
  275.     (void) BoxFClose(tocH);
  276.     (void) BoxFClose(toTocH);
  277.  
  278.     CycleBalls();
  279.     if (!copy) DeleteSum(tocH,sumNum);
  280.         
  281.     CheckBox(FrontWindow());
  282.     return(MessErr);
  283. }
  284.  
  285. /**********************************************************************
  286.  * AppendMessage - add a message to a mailbox.    Message comes from another
  287.  * mailbox.  Things in here are a little touchy, as there are several
  288.  * things to do, any one of which could fail.  In order, this is
  289.  * what is done:
  290.  * 1. Move the bytes from one mailbox to the other.
  291.  * 2. Copy the message summary from one toc to the other, updating
  292.  *        tocH and sumNum in the message handle (if any).
  293.  * 3. If the message window is open, fix pointers so the message
  294.  *        belongs to the new box, not the old one.
  295.  * Steps 1 and 2 could fail.    In either case, no real harm is done,
  296.  * except that we might waste some space in the new mailbox.
  297.  * Step 3 shouldn't ever fail.
  298.  **********************************************************************/
  299. int AppendMessage(TOCType **fromTocH,int fromN,TOCType **toTocH,Boolean copy)
  300. {
  301.     UHandle buffer = nil;
  302.     MSumType sum;
  303.     long eof;
  304.     short err=0;
  305.     MessHandle fromMH;
  306.     
  307.     /*
  308.      * open the relevant mailboxes
  309.      */
  310.     MessErr = BoxFOpen(fromTocH);
  311.     if (MessErr) return(MessErr);
  312.     MessErr = BoxFOpen(toTocH);
  313.     if (MessErr) return(MessErr);
  314.     
  315.     /*
  316.      * if it's an outgoing message, save it first
  317.      */
  318.     fromMH = (*fromTocH)->sums[fromN].messH;
  319.     if (fromMH)
  320.         if ((*fromTocH)->which==OUT)
  321.         {
  322.             MyWindowPtr win = (*fromMH)->win;
  323.             if ((win->isDirty||(*fromTocH)->sums[fromN].flags&FLAG_NBK) &&
  324.                     !SaveComp(win)) return(1);
  325.         }
  326.         else if (!(*fromMH)->win->ro) MessSwapTXE(fromMH);
  327.         
  328.     /*
  329.      * copy the message from one to the other
  330.      */
  331.     eof = FindTOCSpot(toTocH,(*fromTocH)->sums[fromN].length);
  332.     MessErr = CopyFBytes((*fromTocH)->refN,(*fromTocH)->sums[fromN].offset,
  333.         (*fromTocH)->sums[fromN].length,(*toTocH)->refN,eof);
  334.     if (MessErr)
  335.     {
  336.         FileSystemError(COPY_FAILED,(*toTocH)->name,MessErr);
  337.         return(MessErr);
  338.     }
  339.     (void) SetEOF((*toTocH)->refN,eof+(*fromTocH)->sums[fromN].length);
  340.     
  341.     /*
  342.      * now, create a new summary for the copied message, and put it in the
  343.      * new TOC.
  344.      */
  345.     sum = (*fromTocH)->sums[fromN];
  346.     sum.offset = eof;
  347.     sum.selected = False;
  348.     sum.messH = nil;            /* break connection with open message window */
  349.     if (!sum.seconds) sum.seconds = GMTDateTime();
  350.     if ((*fromTocH)->which==OUT)
  351.     {
  352.         if (sum.state!=SENT) sum.state=UNSENT;
  353.         sum.tableId = NO_TABLE;        /* don't translate */
  354.     }
  355.         
  356.     if ((*toTocH)->count)
  357.     {
  358.         MessErr = PtrAndHand(&sum,toTocH,sizeof(sum));
  359.         if (MessErr) return(MessErr);
  360.     }
  361.     else
  362.         (*toTocH)->sums[0] = sum;
  363.     (*toTocH)->dirty = True;
  364.     (*toTocH)->needRedo = MIN((*toTocH)->needRedo,(*toTocH)->count);
  365.     (*toTocH)->count++;
  366.     
  367.     /*
  368.      * the message window, if any, should be closed
  369.      */
  370.     if (!copy && (*fromTocH)->sums[fromN].messH)
  371.         CloseMyWindow((*(MessHandle)(*fromTocH)->sums[fromN].messH)->win);
  372.  
  373.     return(noErr);
  374. }
  375.  
  376.  
  377. /**********************************************************************
  378.  * MoveSelectedMessages - transfer all selected messages from one mail
  379.  * box to another.
  380.  **********************************************************************/
  381. int MoveSelectedMessages(TOCType **tocH,long dirId,UPtr toWhich,Boolean copy)
  382. {
  383.     TOCType **toTocH;
  384.     int sumNum;
  385.     int lastSelected = -1;
  386.     Str31 trashName;
  387.     short oldCount;
  388.     Boolean toTrash = dirId==MyDirId && EqualString(toWhich,GetRString(trashName,TRASH),False,True);
  389.     
  390.     if ((toTocH = TOCByName(dirId,toWhich))==nil)
  391.         return(1);
  392.     
  393.     if (!PrefIsSet(PREF_EASY_DELETE) && (toTrash || (*tocH)->which==OUT))
  394.     {
  395.         for (sumNum = 0; sumNum < (*tocH)->count; sumNum++)
  396.             if ((*tocH)->sums[sumNum].selected &&
  397.                 ((*tocH)->sums[sumNum].state==UNREAD ||
  398.                 (*tocH)->sums[sumNum].state==QUEUED)) break;
  399.         if (sumNum<(*tocH)->count)
  400.         {
  401.             Str31 sent,delete;
  402.             GetRString(sent,(*tocH)->sums[sumNum].state==QUEUED ? SENT_VERB:READ_VERB);
  403.             GetRString(delete,toTrash ? DELETE_VERB : TRANSFER_VERB);
  404.             MyParamText(sent,delete,"","");
  405.             if (ReallyDoAnAlert(TRASH_UNREAD_ALRT,Caution)!=1)
  406.                 return(0);
  407.         }
  408.     }
  409.     
  410.     for (sumNum = 0; sumNum < (*tocH)->count; sumNum++)
  411.     {
  412.         if ((*tocH)->sums[sumNum].selected)
  413.         {
  414.             CycleBalls();
  415.             oldCount = (*tocH)->count;
  416.             MessErr=AppendMessage(tocH,sumNum,toTocH,copy);
  417.             if (MessErr) break;
  418.             if (oldCount!=(*tocH)->count)
  419.             {
  420.                 lastSelected = sumNum;
  421.                 sumNum--;
  422.             }
  423.             else if (!copy)
  424.             {
  425.                 DeleteSum(tocH,sumNum);
  426.                 lastSelected = sumNum;
  427.                 sumNum--;         /* back up, so we can try again */
  428.             }
  429.         }
  430.     }
  431.     (void) BoxFClose(tocH);
  432.     (void) BoxFClose(toTocH);
  433.  
  434.     if ((*tocH)->win && !copy) BoxSelectAfter((*tocH)->win,lastSelected);
  435.     CheckBox(FrontWindow());
  436.         
  437.     return(MessErr);
  438. }
  439.  
  440. /**********************************************************************
  441.  * DeleteMessage - delete a summary from a toc, and fix the screen, too
  442.  **********************************************************************/
  443. void DeleteMessage(TOCType **tocH, int sumNum)
  444. {
  445.     MessType **messH = (MessType **)(*tocH)->sums[sumNum].messH;
  446.     Boolean dirt = 0;
  447.     Str63 trashName;
  448.     int oldN = (*tocH)->count;
  449.     
  450.     if ((*tocH)->which!=TRASH)
  451.     {
  452.         GetRString(trashName,TRASH);
  453.         MoveMessage(tocH,sumNum,MyDirId,trashName,False);
  454.     }
  455.     else
  456.     {
  457.         if (messH) CloseMyWindow((*messH)->win);
  458.         DeleteSum(tocH,sumNum);
  459.     }
  460. } 
  461.  
  462. /************************************************************************
  463.  * MessageError - return the most recent error code from these functions
  464.  ************************************************************************/
  465. int MessageError(void)
  466. {
  467.     return(MessErr);
  468. }
  469.  
  470. /************************************************************************
  471.  * WeedHeaders - weed a message's headers, leaving only the interesting
  472.  * ones.
  473.  ************************************************************************/
  474. void WeedHeaders(UHandle buffer,long *weeded,short toWeed)
  475. {
  476.     UPtr spot = LDRef(buffer);
  477.     UPtr done = spot;
  478.     UPtr end = spot + GetHandleSize(buffer);
  479.     long size;
  480.     Str31 badName;
  481.     short bad;
  482.     
  483.     while (spot<end)
  484.     {
  485.         if (*spot=='\n') break;
  486.         for (bad=1;*GetRString(badName,toWeed+bad);bad++)
  487.             if (!striscmp(spot,badName+1))
  488.             {
  489.                 while (spot<end)
  490.                     if (*spot++=='\n')
  491.                         if (*spot!=' ' && *spot!='\t') break;
  492.                 goto nextHead;
  493.             }
  494.         while (spot<end)
  495.             if ((*done++ = *spot++)=='\n')
  496.                 if (*spot!=' ' && *spot!='\t') break;
  497.         nextHead:;
  498.     }
  499.     
  500.     while (spot<end) *done++ = *spot++;
  501.     size = done - *buffer;
  502.     if (weeded) *weeded = end-done;
  503.     HUnlock(buffer);
  504.     SetHandleBig(buffer,size);
  505. }
  506.  
  507. /************************************************************************
  508.  * SetMessText - stick some text into one of the fields of a message.
  509.  ************************************************************************/
  510. void SetMessText(MessType **messH,short whichTXE,UPtr string,short size)
  511. {
  512.     TEHandle teh = (*messH)->txes[whichTXE];
  513.     int oldNl = CountTeLines(teh);
  514.  
  515.     TESetText(string,size,teh);
  516.     FixMessTE(messH,whichTXE,oldNl);
  517. }
  518.  
  519. /************************************************************************
  520.  * AppendMessText - stick some text after one of the fields of a message.
  521.  ************************************************************************/
  522. void AppendMessText(MessType **messH,short whichTXE,UPtr string,short size)
  523. {
  524.     TEHandle teh = (*messH)->txes[whichTXE];
  525.     int oldNl = CountTeLines(teh);
  526.  
  527.     NoScrollTESetSelect(INFINITY,INFINITY,teh);
  528.     TEInsert(string,size,teh);
  529.     FixMessTE(messH,whichTXE,oldNl);
  530. }
  531.  
  532. /************************************************************************
  533.  * FixMessTE - fix up a te in a message
  534.  ************************************************************************/
  535. FixMessTE(MessType **messH,short whichTXE,short oldNl)
  536. {
  537.     MyWindowPtr win = (*messH)->win;
  538.     TEHandle oldTXE;
  539.     short newNl;
  540.     
  541.     if (win)
  542.     {
  543.         oldTXE = win->txe;
  544.         win->txe = (*messH)->txes[whichTXE];
  545.         newNl = CountTeLines(win->txe);
  546.         CompTxChanged(win,oldNl,newNl,False);
  547.         INVAL_RECT(&(*win->txe)->destRect);
  548.         win->txe = oldTXE;
  549.     }
  550. }
  551.  
  552.  
  553. /************************************************************************
  554.  * DoIterativeThingy - do something over all selected messages
  555.  ************************************************************************/
  556. void DoIterativeThingy(TOCType **tocH,int item,long modifiers,short toWhom)
  557. {
  558.     int sumNum;
  559.     MessType **messH;
  560.     MyWindowPtr win;
  561.     short lastSelected = -1;
  562.     Str255 title;
  563.  
  564. #ifdef PERF
  565.     PerfControl(ThePGlobals,True);
  566. #endif PERF
  567.  
  568.     if (item==MESSAGE_DELETE_ITEM && (*tocH)->which!=TRASH)
  569.     {
  570.         GetRString(title,TRASH);
  571.         MoveSelectedMessages(tocH,MyDirId,title,False);
  572.         return;
  573.     }
  574.     
  575.     OpenProgress();
  576.     
  577.     for (sumNum=(*tocH)->count-1;!EjectBuckaroo && sumNum>=0;sumNum--)
  578.     {
  579.         if ((*tocH)->sums[sumNum].selected)
  580.         {
  581.             lastSelected = sumNum;
  582.             MakeMessTitle(title,tocH,sumNum);
  583.             Progress(NoChange,title);
  584.             switch(item)
  585.             {
  586.                 case MESSAGE_DELETE_ITEM:
  587.                     DeleteMessage(tocH,sumNum);
  588.                     break;
  589.                 default:
  590.                     messH = (*tocH)->sums[sumNum].messH;
  591.                     if (messH || GetAMessage(tocH,sumNum,nil,False))
  592.                     {
  593.                         win = (*(MessType **)(*tocH)->sums[sumNum].messH)->win;
  594.                         UsingWindow(win);
  595.                         switch(item)
  596.                         {
  597.                             case MESSAGE_SALVAGE_ITEM:
  598.                                 DoSalvageMessage(win);
  599.                                 break;
  600.                             case MESSAGE_FORWARD_ITEM:
  601.                                 DoForwardMessage(win,toWhom);
  602.                                 break;
  603.                             case MESSAGE_REPLY_ITEM:
  604.                                 DoReplyMessage(win,modifiers,toWhom,True);
  605.                                 break;
  606.                             case MESSAGE_REDISTRIBUTE_ITEM:
  607.                                 DoRedistributeMessage(win,toWhom);
  608.                                 break;
  609.                         }
  610.                         if (!messH)
  611.                             CloseMyWindow(win);
  612.                         else
  613.                             NotUsingWindow(win);
  614.                     }
  615.                 }
  616.             }
  617.             MonitorGrow();
  618.     }
  619.     CloseProgress();
  620.     BoxSelectAfter((*tocH)->win,lastSelected);
  621.     CheckBox(FrontWindow());
  622. #ifdef PERF
  623.     PerfControl(ThePGlobals,False);
  624. #endif
  625. }
  626.  
  627. /************************************************************************
  628.  * BoxNextSelected - find first selection in a mailbox
  629.  ************************************************************************/
  630. short BoxNextSelected(TOCHandle tocH,short afterNum)
  631. {
  632.     int sNum, count;
  633.     
  634.     count = (*tocH)->count;
  635.     
  636.     for (sNum=afterNum+1;sNum<count;sNum++)
  637.         if ((*tocH)->sums[sNum].selected) return(sNum);
  638.     
  639.     return(-1);
  640. }
  641.  
  642. #pragma segment MsgOps
  643. /************************************************************************
  644.  * DoSalvageMessage - glean what you can from a bounced message's headers
  645.  ************************************************************************/
  646. short DoSalvageMessage(MyWindowPtr win)
  647. {
  648.     MessType **origMessH = (MessType **)((WindowPeek)win)->refCon;
  649.     MessType **newMessH;
  650.     MyWindowPtr newWin;
  651.     Str255 scratch;
  652.     
  653.     if (newWin=DoComposeNew(0))
  654.     {
  655.         newMessH = (MessType **)newWin->qWindow.refCon;
  656.         XferCustomTable(origMessH,newMessH);        
  657.         if (win->qWindow.windowKind==COMP_WIN)
  658.         {
  659.             short tx;
  660.             for (tx=0;tx<sizeof((*newMessH)->txes)/sizeof(TEHandle);tx++)
  661.             {
  662.                 TESetText(LDRef((*(*origMessH)->txes[tx])->hText),
  663.                     (*(*origMessH)->txes[tx])->teLength,(*newMessH)->txes[tx]);
  664.                 UL((*(*origMessH)->txes[tx])->hText);
  665.             }
  666.             (*(*newMessH)->tocH)->dirty = True;
  667.             SumOf(newMessH)->flags = SumOf(origMessH)->flags;
  668.         }
  669.         else
  670.         {
  671.             UPtr spot, oldSpot, beginning;
  672.             long size, total;
  673.             Boolean toFound;
  674.             Str63 received;
  675.             
  676.             beginning = spot = LDRef((*Win2Body(win))->hText);
  677.             total = size = GetHandleSize((*Win2Body(win))->hText);
  678.             
  679.             /*
  680.              * find the last "Received:" header
  681.              */
  682.             GetRString(received,RECEIVED_HEAD); TrimWhite(received);
  683.             for (oldSpot = nil;
  684.                      spot=FindHeaderString(spot,received,&size);
  685.                      oldSpot=spot,spot+=size,size=total-(spot-beginning-size));
  686.             
  687.             /*
  688.              * copy the relevant parts
  689.              */
  690.             if (!oldSpot) oldSpot=beginning;
  691.             {
  692.                 if (oldSpot!=beginning)
  693.                     SumOf(newMessH)->flags &= ~FLAG_SIG;
  694.                 size = total - (oldSpot-beginning);
  695.                 TextFindAndCopyHeader(oldSpot,size,newMessH,HeaderName(SUBJ_HEAD),SUBJ_HEAD);
  696.                 TextFindAndCopyHeader(oldSpot,size,newMessH,HeaderName(CC_HEAD),CC_HEAD);
  697.                 TextFindAndCopyHeader(oldSpot,size,newMessH,HeaderName(ATTACH_HEAD),ATTACH_HEAD);
  698.                 toFound = TextFindAndCopyHeader(oldSpot,size,newMessH,HeaderName(TO_HEAD),TO_HEAD);
  699.                 TextFindAndCopyHeader(oldSpot,size,newMessH,HeaderName(BCC_HEAD),BCC_HEAD);
  700.                 /*
  701.                  * find the body
  702.                  */
  703.                 for (spot=oldSpot;spot<oldSpot+size-1;spot++)
  704.                     if (spot[0]=='\n' && spot[1]=='\n') break;
  705.                 spot += 2;
  706.                 if (spot<oldSpot+size-1)
  707.                     SetMessText(newMessH,HEAD_LIMIT-1,spot,total-(spot-beginning));
  708.                 HUnlock((*Win2Body(win))->hText);
  709.             }
  710.         }
  711.         UpdateSum(newMessH,SumOf(newMessH)->offset,SumOf(newMessH)->length);
  712.         ShowMyWindow(newWin);
  713.         newWin->isDirty = False;
  714.     }
  715.     return(!newWin);
  716. }
  717.  
  718. /************************************************************************
  719.  * RemoveSelf - Remove "me" from a list of addresses
  720.  *    Ray Davison, SFU
  721.  ************************************************************************/
  722. void RemoveSelf(MessHandle messH,short head)
  723. {
  724.                 Str63 temp,dummy;
  725.                 UHandle rawMyself, cookedMyself;
  726.                 UHandle rawAddress, spewHandle;
  727.                 UHandle myself=NewHandle(0);
  728.                 long offset, meOffset;
  729.                 Boolean removed = False;
  730.                 Handle text = (*(*messH)->txes[head-1])->hText;
  731.                 short nLines = CountTeLines((*messH)->txes[head-1]);
  732.                 
  733.                 /* Get a definition of who I am */
  734.                 
  735.                 GetRString(temp, ME);
  736.                 PtrAndHand(temp+1, myself, temp[0]);
  737.                 PtrAndHand(",", myself, 1);
  738.                 GetPOPInfo(temp, dummy);
  739.                 PtrAndHand(temp+1, myself, temp[0]);
  740.                 PtrAndHand(",", myself, 1);
  741.                 GetReturnAddr(temp ,True);
  742.                 PtrAndHand(temp+1, myself, temp[0]);
  743.                 rawMyself = SuckAddresses(myself, GetHandleSize(myself), False);
  744.                 cookedMyself = ExpandAliases(rawMyself, 0, False);
  745.                 DisposHandle(rawMyself);
  746.                 DisposHandle(myself);
  747.                 
  748.                 /* expand the text */
  749.                 
  750.                 rawAddress = SuckAddresses(text, GetHandleSize(text), True);
  751.                 SetHandleSize(text, 0);
  752.                 
  753.                 /* Remove myself from address */
  754.                 LDRef(cookedMyself);
  755.                 for (offset=0; (*rawAddress)[offset]; offset += (*rawAddress)[offset]+2)
  756.                 {
  757.                                 /* clean up the address */
  758.                                 LDRef(rawAddress);
  759.                                 spewHandle = SuckPtrAddresses((*rawAddress)+offset+1,
  760.                                                 (*rawAddress)[offset], False);
  761.                                 UL(rawAddress);
  762.                                 LDRef(spewHandle);
  763.                                 /* look for this in the "me" addresses */
  764.                                 for (meOffset=0; (*cookedMyself)[meOffset]; meOffset += (*cookedMyself)[meOffset]+2)
  765.                                 {
  766.                                 if (EqualString(*spewHandle,*cookedMyself+meOffset,False,True))
  767.                                     break;
  768.                                 }
  769.                                 DisposHandle(spewHandle);
  770.                 
  771.                                 /* if we didn't find it, then add this address to the result */
  772.                                 if (!(*cookedMyself)[meOffset])
  773.                                 {
  774.                                                 LDRef(rawAddress);
  775.                                                 if (GetHandleSize(text)) PtrAndHand(", ", text, 2);
  776.                                                 PtrAndHand((*rawAddress)+offset+1,text,(*rawAddress)[offset]);
  777.                                                 HUnlock(rawAddress);
  778.                                 }
  779.                                 else removed = True;
  780.                 }
  781.                 
  782.                 DisposHandle(cookedMyself);
  783.                 DisposHandle(rawAddress);
  784.                 if (removed)
  785.                 {
  786.                     (*(*messH)->txes[head-1])->teLength = GetHandleSize(text);
  787.                     FixMessTE(messH,head-1,nLines);
  788.                 }
  789. }
  790.  
  791. /************************************************************************
  792.  * ReopenMessage - reopen the current message
  793.  ************************************************************************/
  794. MyWindowPtr ReopenMessage(MyWindowPtr win)
  795. {
  796.     TOCHandle tocH = (*Win2MessH(win))->tocH;
  797.     short sumNum = (*Win2MessH(win))->sumNum;
  798.     
  799.     CloseMyWindow(win);
  800.     return(OpenMessage(tocH,sumNum,nil,True));
  801. }
  802.  
  803. /************************************************************************
  804.  * FindFrom - find a (nicely formatted) From address
  805.  ************************************************************************/
  806. void FindFrom(UPtr who, MessHandle messH)
  807. {
  808.     UPtr found;
  809.     Str31 header;
  810.   long len;
  811.     
  812.     if ((*(*messH)->tocH)->which==OUT)
  813.     {
  814.       len = (*(*messH)->txes[FROM_HEAD-1])->teLength;
  815.         *who = MIN(63,len);
  816.         BlockMove(*(*(*messH)->txes[FROM_HEAD-1])->hText,who+1,*who);
  817.         if (*who) BeautifyFrom(who);
  818.     }
  819.     else
  820.     {
  821.          len = (*BodyOf(messH))->teLength;
  822.         GetRString(header,FROM_HEAD+HEADER_STRN);
  823.         if (found = FindHeaderString(LDRef((*BodyOf(messH))->hText),header,&len))
  824.         {
  825.             *who = MIN(len,254);
  826.             BlockMove(found,who+1,*who);
  827.             who[*who+1] = 0;
  828.             BeautifyFrom(who);
  829.         }
  830.         else *who = 0;
  831.         UL((*BodyOf(messH))->hText);
  832.     }
  833. }
  834.  
  835. /************************************************************************
  836.  * QuoteLines - put a quote prefix before the specified TextEdit lines
  837.  ************************************************************************/
  838. void QuoteLines(MessType **messH,short whichTXE,int from,int to,short pfid)
  839. {
  840.     GrafPtr oldPort;
  841.     int oldNl;
  842.     MyWindowPtr win=(*messH)->win;
  843.     TEHandle teh = (*messH)->txes[whichTXE];
  844.     long ticks = TickCount();
  845.     short lastSpot, spot;
  846.     short this;
  847.     short expand=0;
  848.     short bSize;
  849.     UPtr copied;
  850.     Str15 prefix;
  851.     
  852.     GetPort(&oldPort);SetPort((*teh)->inPort);
  853.     
  854.     GetRString(prefix,pfid);
  855.     if (!*prefix) return;
  856.     oldNl = CountTeLines(teh);
  857. #define HARD_NL(i) (!(*teh)->lineStarts[i] ||\
  858.                 (*(*teh)->hText)[(*teh)->lineStarts[i]-1] == '\n')
  859.  
  860.     for (this=to;this>=from;this--)
  861.         if (HARD_NL(this)) expand += *prefix;
  862.     if (expand)
  863.     {
  864.         SetHandleBig((*teh)->hText,(*teh)->teLength+expand);
  865.         if (MemError()) return;
  866.         lastSpot = (*teh)->teLength;
  867.         copied = *(*teh)->hText+lastSpot+expand;
  868.         for (this=to;this>=from;this--)
  869.             if (HARD_NL(this))
  870.             {
  871.                 spot = (*teh)->lineStarts[this];
  872.                 bSize = lastSpot-spot;
  873.                 BlockMove(*(*teh)->hText+spot,copied-bSize,bSize);
  874.                 copied -= bSize + *prefix;
  875.                 BlockMove(prefix+1,copied,*prefix);
  876.                 lastSpot = spot;
  877.             }
  878.         (*teh)->teLength += expand;
  879.         TECalText(teh);
  880.         INVAL_RECT(&(*teh)->viewRect);
  881.         UpdateMyWindow(win);
  882.     }
  883.     win->txe = teh;
  884.     CompTxChanged((*teh)->inPort,oldNl,CountTeLines(teh),True);
  885.     SetPort(oldPort);
  886. }
  887.  
  888. /************************************************************************
  889.  * PrependMessText - stick some text before one of the fields of a message.
  890.  ************************************************************************/
  891. void PrependMessText(MessType **messH,short whichTXE,UPtr string,short size)
  892. {
  893.     TEHandle teh = (*messH)->txes[whichTXE];
  894.     int oldNl = CountTeLines(teh);
  895.  
  896.     NoScrollTESetSelect(0,0,teh);
  897.     TEInsert(string,size,teh);
  898.     FixMessTE(messH,whichTXE,oldNl);
  899. }
  900.  
  901. /************************************************************************
  902.  * FindHeaderString - pick the given header out of a message, by name
  903.  ************************************************************************/
  904. UPtr FindHeaderString(UPtr text,UPtr headerName,long *size)
  905. {
  906.     UPtr spot,end;
  907.     char header[MAX_HEADER];
  908.     
  909.     for (end = text+*size; text<end; text = spot+1)
  910.     {
  911.         for (spot=text;spot<end;spot++) if (*spot == '\n') break;
  912.         BlockMove(text,header+1,*headerName);
  913.         *header = *headerName;
  914.         if (EqualString(header,headerName,False,False))
  915.         {
  916.             text += *headerName;
  917.             while (*text==' ' || *text=='\t') text++;
  918.             for (spot--; IsWhite(*spot); spot--);
  919.             *size = spot-text+1;
  920.             return(spot>=text ? text : nil);
  921.         }
  922.     }
  923.     return(nil);
  924. }
  925. /************************************************************************
  926.  * DoReplyMessage - craft a reply to a message
  927.  ************************************************************************/
  928. MyWindowPtr DoReplyMessage(MyWindowPtr win, long modifiers, short toWhom,Boolean vis)
  929. {
  930.     MessHandle origMessH = (MessType **)((WindowPeek)win)->refCon;
  931.     MessHandle newMessH;
  932.     Str255 subj,scratch;
  933.     short bodyOffset = -1;
  934.     MyWindowPtr newWin=nil;
  935.     short nLines, r;
  936.     TEHandle teh;
  937.     short len;
  938.     Boolean all = PrefIsSet(PREF_REPLY_ALL);
  939.     Boolean quote = !(modifiers & shiftKey);
  940.     Boolean notMe = PrefIsSet(PREF_NOT_ME);
  941.     
  942.     if (modifiers&optionKey) all = !all;
  943.     
  944.     if (newWin=DoComposeNew(toWhom))
  945.     {
  946.         newMessH = (MessHandle) newWin->qWindow.refCon;
  947.         
  948.         XferCustomTable(origMessH,newMessH);
  949.         
  950.         /* handle the subject */
  951.         FindAndCopyHeader(origMessH,newMessH,HeaderName(SUBJ_HEAD),SUBJ_HEAD);
  952.         GetRString(scratch,REPLY_INTRO);
  953.         BlockMove(*(*(*newMessH)->txes[SUBJ_HEAD-1])->hText,subj+1,*scratch);
  954.         *subj = *scratch;
  955.         if (!EqualString(subj,scratch,False,False))
  956.             PrependMessText(newMessH,SUBJ_HEAD-1,scratch+1,*scratch);
  957.             
  958.         /* reply to sender */
  959.         if (!toWhom)
  960.         {
  961.             for (r=1;*GetRString(scratch,REPLY_STRN+r);r++)
  962.             {
  963.                 TrimWhite(scratch);
  964.                 if (FindAndCopyHeader(origMessH,newMessH,scratch,TO_HEAD)) break;
  965.             }
  966.       }
  967.         
  968.         /* bring over the other recipients and cc's, if desired */
  969.         if (all && !toWhom)
  970.         {
  971.             FindAndCopyHeader(origMessH,newMessH,HeaderName(TO_HEAD),TO_HEAD);
  972.             FindAndCopyHeader(origMessH,newMessH,HeaderName(CC_HEAD),CC_HEAD);
  973.  
  974.             /* remove self, if desired */
  975.             if (notMe)
  976.             {
  977.                 RemoveSelf(newMessH,TO_HEAD);
  978.                 RemoveSelf(newMessH,CC_HEAD);
  979.             }
  980.         }
  981.         
  982.         if (quote)
  983.         {
  984.             bodyOffset = SumOf(origMessH)->bodyOffset-(*origMessH)->weeded;
  985.             while ((*(*Win2Body(win))->hText)[bodyOffset] == '\n' &&
  986.                          bodyOffset<(*Win2Body(win))->teLength) bodyOffset++;
  987.             len = (*Win2Body(win))->teLength-bodyOffset;
  988.         }
  989.         else if ((*Win2Body(win))->selStart != (*Win2Body(win))->selEnd)
  990.         {
  991.             bodyOffset = (*Win2Body(win))->selStart;
  992.             len = (*Win2Body(win))->selEnd - bodyOffset;
  993.         }
  994.         
  995.         if (bodyOffset >= 0)
  996.         {
  997.             while (len && (*(*Win2Body(win))->hText)[bodyOffset+len-1]=='\n') len--;
  998.             {
  999.                 UPtr mpw_bug = LDRef((*Win2Body(win))->hText);
  1000.                 SetMessText(newMessH,HEAD_LIMIT-1,mpw_bug+bodyOffset,len);
  1001.             }
  1002.             HUnlock((*Win2Body(win))->hText);
  1003.             UpdateMyWindow(newWin);
  1004.             
  1005.             /*
  1006.              * make sure the last line is blank
  1007.              */
  1008.             teh = (*newMessH)->txes[HEAD_LIMIT-1];
  1009.             nLines = (*teh)->nLines-1;
  1010.             if (!nLines ||
  1011.                     (*teh)->lineStarts[nLines-1]-(*teh)->lineStarts[nLines-2]!=1)
  1012.                 AppendMessText(newMessH,HEAD_LIMIT-1,"\n",1);
  1013.  
  1014.             /*
  1015.              * quote them
  1016.              */
  1017.             QuoteLines(newMessH,HEAD_LIMIT-1,0,nLines,QUOTE_PREFIX);
  1018.             
  1019.             /*
  1020.              * annotate
  1021.              */
  1022.             Attribute(all ? ATTRIBUTION:REP_SEND_ATTR,origMessH,newMessH,False);
  1023.         }
  1024.  
  1025.         /*
  1026.          * copy priority (not my idea)
  1027.          */
  1028.         if (!PrefIsSet(PREF_NO_XF_PRIOR))
  1029.             SumOf(newMessH)->origPriority = SumOf(newMessH)->priority =
  1030.                 SumOf(origMessH)->origPriority;
  1031.         
  1032.         if (vis)
  1033.         {
  1034.             SetState((*origMessH)->tocH,(*origMessH)->sumNum,REPLIED);
  1035.             UpdateSum(newMessH,SumOf(newMessH)->offset,SumOf(newMessH)->length);
  1036.             ShowMyWindow(newWin);
  1037.         }
  1038.         newWin->isDirty = False;
  1039.     }
  1040.     return(newWin);
  1041. }
  1042.  
  1043. /************************************************************************
  1044.  * Attribute - make an attribution
  1045.  ************************************************************************/
  1046. void Attribute(short attrId,MessHandle origMessH,MessHandle newMessH,Boolean atEnd)
  1047. {
  1048.     Str63 template,date;
  1049.     Str127 who;
  1050.     Str255 attribution;
  1051.     
  1052.     GetRString(template,attrId);
  1053.     if (*template)
  1054.     {
  1055.         MSumPtr sum = LDRef((*origMessH)->tocH)->sums+(*origMessH)->sumNum;
  1056.         FindFrom(who,origMessH);
  1057.         if (*who)
  1058.         {
  1059.             PCopy(date,sum->date);
  1060.             if (date[1]==optSpace) date[1] = ' ';
  1061.             utl_PlugParams(template,attribution,who,date,sum->subj,nil);
  1062.             if (atEnd)
  1063.                 AppendMessText(newMessH,HEAD_LIMIT-1,attribution+1,*attribution);
  1064.             else
  1065.                 PrependMessText(newMessH,HEAD_LIMIT-1,attribution+1,*attribution);
  1066.         }
  1067.         UL((*origMessH)->tocH);
  1068.     }
  1069. }
  1070.  
  1071. /************************************************************************
  1072.  * DoRedistributeMessage - craft a reply to a message
  1073.  ************************************************************************/
  1074. short DoRedistributeMessage(MyWindowPtr win,short toWhom)
  1075. {
  1076.     MessType **origMessH = (MessType **)((WindowPeek)win)->refCon;
  1077.     MessType **newMessH;
  1078.     Str255 scratch, who;
  1079.     int bodyOffset;
  1080.     MyWindowPtr newWin;
  1081.     TEHandle body;
  1082.     
  1083.     if (newWin=DoComposeNew(toWhom))
  1084.     {
  1085.         newMessH = (MessType **)newWin->qWindow.refCon;
  1086.         XferCustomTable(origMessH,newMessH);        
  1087.         SetMessText(newMessH,FROM_HEAD-1,"",0);
  1088.         FindAndCopyHeader(origMessH,newMessH,HeaderName(SUBJ_HEAD),SUBJ_HEAD);
  1089.         FindAndCopyHeader(origMessH,newMessH,HeaderName(FROM_HEAD),FROM_HEAD);
  1090.         FindAndCopyHeader(origMessH,newMessH,HeaderName(ATTACH_HEAD),ATTACH_HEAD);
  1091.         GetReturnAddr(who,True);
  1092.         *scratch = (*(*newMessH)->txes[FROM_HEAD-1])->teLength;
  1093.         BlockMove(*(*(*newMessH)->txes[FROM_HEAD-1])->hText,scratch+1,*scratch);
  1094.         if (!EqualString(scratch,who,False,True))
  1095.         {
  1096.             ComposeRString(scratch,REDIST_ANNOTATE,who);
  1097.             AppendMessText(newMessH,FROM_HEAD-1,scratch+1,*scratch);
  1098.         }
  1099.         bodyOffset = (*(*origMessH)->tocH)->sums[(*origMessH)->sumNum].bodyOffset;
  1100.         bodyOffset -= (*origMessH)->weeded;
  1101.         body = Win2Body(win);
  1102.         while((*(*body)->hText)[bodyOffset]=='\n' && bodyOffset<(*body)->teLength-1)
  1103.             bodyOffset++;
  1104.         SetMessText(newMessH,HEAD_LIMIT-1,
  1105.                          LDRef((*Win2Body(win))->hText)+bodyOffset,
  1106.                          (*Win2Body(win))->teLength-bodyOffset);
  1107.         HUnlock((*Win2Body(win))->hText);
  1108.         if (SumOf(origMessH)->state!=SENT && SumOf(origMessH)->state!=UNSENT)
  1109.             SumOf(newMessH)->flags &= ~FLAG_SIG;
  1110.  
  1111.         /*
  1112.          * copy priority
  1113.          */
  1114.         SumOf(newMessH)->origPriority = SumOf(newMessH)->priority =
  1115.             SumOf(origMessH)->origPriority;
  1116.         
  1117.         SetState((*origMessH)->tocH,(*origMessH)->sumNum,REDIST);
  1118.         UpdateSum(newMessH,SumOf(newMessH)->offset,SumOf(newMessH)->length);
  1119.         ShowMyWindow(newWin);
  1120.         newWin->isDirty = False;
  1121.     }
  1122.     return(!newWin);
  1123. }
  1124.  
  1125. /************************************************************************
  1126.  * DoForwardMessage - forward a message to someone
  1127.  ************************************************************************/
  1128. short DoForwardMessage(MyWindowPtr win,short toWhom)
  1129. {
  1130.     MessType **origMessH = (MessType **)((WindowPeek)win)->refCon;
  1131.     MessType **newMessH;
  1132.     MyWindowPtr newWin;
  1133.     short nLines;
  1134.     TEHandle teh;
  1135.     Str255 scratch;
  1136.     
  1137.     if (newWin=DoComposeNew(toWhom))
  1138.     {
  1139.         newMessH = (MessType **)newWin->qWindow.refCon;
  1140.         XferCustomTable(origMessH,newMessH);        
  1141.         if (SumOf(origMessH)->flags&FLAG_OUT)
  1142.         {
  1143.             BuildDateHeader(scratch,SumOf(origMessH)->seconds);
  1144.             AppendMessText(newMessH,HEAD_LIMIT-1,scratch+1,*scratch);
  1145.             AppendMessText(newMessH,HEAD_LIMIT-1,"\n",1);
  1146.         }
  1147.         if (win->qWindow.windowKind==COMP_WIN)
  1148.         {
  1149.             short tx;
  1150.             for (tx=0;tx<HEAD_LIMIT;tx++)
  1151.             {
  1152.                 teh = (*origMessH)->txes[tx];
  1153.                 if ((*teh)->teLength)
  1154.                 {
  1155.                     if (tx<HEAD_LIMIT-1)
  1156.                     {
  1157.                         GetRString(scratch,HEADER_STRN+tx+1);
  1158.                         AppendMessText(newMessH,HEAD_LIMIT-1,scratch+1,*scratch);
  1159.                     }
  1160.                     AppendMessText(newMessH,HEAD_LIMIT-1,LDRef((*teh)->hText),(*teh)->teLength);
  1161.                     UL((*teh)->hText);
  1162.                     if ((*(*teh)->hText)[(*teh)->teLength-1]!='\n')
  1163.                         AppendMessText(newMessH,HEAD_LIMIT-1,"\n",1);
  1164.                 }
  1165.                 if (tx==HEAD_LIMIT-2) AppendMessText(newMessH,HEAD_LIMIT-1,"\n",1);
  1166.             }
  1167.             TESetText(LDRef((*(*origMessH)->txes[SUBJ_HEAD-1])->hText),
  1168.                 (*(*origMessH)->txes[SUBJ_HEAD-1])->teLength,
  1169.                 (*newMessH)->txes[SUBJ_HEAD-1]);
  1170.             UL((*(*origMessH)->txes[SUBJ_HEAD-1])->hText);
  1171.         }
  1172.         else
  1173.         {
  1174.             FindAndCopyHeader(origMessH,newMessH,HeaderName(SUBJ_HEAD),SUBJ_HEAD);
  1175.             /*
  1176.              * stick it in
  1177.              */
  1178.             AppendMessText(newMessH,HEAD_LIMIT-1,LDRef((*Win2Body(win))->hText),
  1179.                                                             (*Win2Body(win))->teLength);
  1180.             HUnlock((*Win2Body(win))->hText);
  1181.         }
  1182.         
  1183.         UpdateMyWindow(newWin);
  1184.             
  1185.         /*
  1186.          * make sure the last line is blank
  1187.          */
  1188.         teh = (*newMessH)->txes[HEAD_LIMIT-1];
  1189.         nLines = (*teh)->nLines;
  1190.         if ((*teh)->lineStarts[nLines-1]-(*teh)->lineStarts[nLines-2]==1)
  1191.             nLines--;
  1192.         else
  1193.             AppendMessText(newMessH,HEAD_LIMIT-1,"\n",1);
  1194.  
  1195.         /*
  1196.             * quote them
  1197.             */
  1198.         QuoteLines(newMessH,HEAD_LIMIT-1,0,nLines,FWD_QUOTE);
  1199.         if (win->qWindow.windowKind!=COMP_WIN)
  1200.             SetState((*origMessH)->tocH,(*origMessH)->sumNum,FORWARDED);
  1201.       
  1202.         /*
  1203.          * Attributions
  1204.          */
  1205.         Attribute(FWD_INTRO,origMessH,newMessH,False);
  1206.         Attribute(FWD_TRAIL,origMessH,newMessH,True);
  1207.  
  1208.         /*
  1209.          * copy priority (not my idea)
  1210.          */
  1211.         if (!PrefIsSet(PREF_NO_XF_PRIOR))
  1212.             SumOf(newMessH)->origPriority = SumOf(newMessH)->priority =
  1213.                 SumOf(origMessH)->origPriority;
  1214.         
  1215.         UpdateSum(newMessH,SumOf(newMessH)->offset,SumOf(newMessH)->length);
  1216.         ShowMyWindow(newWin);
  1217.         newWin->isDirty = False;
  1218.     }
  1219.     return(!newWin);
  1220. }
  1221.  
  1222. /************************************************************************
  1223.  * FindAndCopyHeader - pick the given header out of a message, and
  1224.  * copy it to a composition message
  1225.  ************************************************************************/
  1226. int FindAndCopyHeader(MessType **origMH,MessType **newMH,UPtr fromHead,short toHead)
  1227. {
  1228.     UPtr body;
  1229.     long size;
  1230.     int result;
  1231.     
  1232.     body = LDRef((*BodyOf(origMH))->hText);
  1233.     size = SumOf(origMH)->bodyOffset-(*origMH)->weeded;
  1234.     result = TextFindAndCopyHeader(body,size,newMH,fromHead,toHead);
  1235.     HUnlock((*BodyOf(origMH))->hText);
  1236.     return(result);
  1237. }
  1238.  
  1239. /************************************************************************
  1240.  * TextFindAndCopyHeader - pick the given header out of a text block, and
  1241.  * copy it to a composition message
  1242.  ************************************************************************/
  1243. int TextFindAndCopyHeader(UPtr body,long size,MessType **newMH,UPtr fromHead,short toHead)
  1244. {
  1245.     int oldNl;
  1246.     short oldBody;
  1247.     MyWindowPtr newWin = (*newMH)->win;
  1248.     UPtr bodyEnd = body+size;
  1249.     UPtr spot;
  1250.         
  1251.     if (body = FindHeaderString(body,fromHead,&size))
  1252.     {
  1253.         TEHandle teh = (*newMH)->txes[toHead-1];
  1254.         oldNl = CountTeLines(teh);
  1255.         
  1256.         for(;;)
  1257.         {
  1258.             oldBody = (*teh)->teLength;
  1259.             NoScrollTESetSelect(oldBody,oldBody,teh);
  1260.             if (oldBody)
  1261.             {
  1262.                 for (spot=*(*teh)->hText+oldBody-1;spot>*(*teh)->hText;spot--)
  1263.                     if (!IsWhite(*spot))
  1264.                     {
  1265.                         if (*spot!=',')
  1266.                             TEInsert(", ",2,teh);
  1267.                         else if (spot==*(*teh)->hText+oldBody-1)
  1268.                             TEInsert(" ",1,teh);
  1269.                         break;
  1270.                     }
  1271.             }
  1272.             TEInsert(body,size,teh);
  1273.             
  1274.             body += size;
  1275.             while (IsWhite(*body)&&body<bodyEnd) body++;            /* skip to newline */
  1276.             body++;                                                                                     /* skip newline */
  1277.             if (body<bodyEnd && IsWhite(*body))                             /* continuation */
  1278.             {
  1279.                 while (IsWhite(*body)&&body<bodyEnd) body++;
  1280.                 for (spot=body;spot<bodyEnd&&*spot!='\n';spot++);
  1281.                 do {spot--;} while (IsWhite(*spot));
  1282.                 size = spot-body+1;
  1283.                 if (!size) break;
  1284.             }
  1285.             else
  1286.                 break;
  1287.         }
  1288.         
  1289.         INVAL_RECT(&(*teh)->destRect);
  1290.         FixMessTE(newMH,toHead-1,oldNl);
  1291.     }
  1292.     return(body!=nil);
  1293. }
  1294.  
  1295. /************************************************************************
  1296.  * XferCustomTable - transfer a custom table from a message to its reply
  1297.  * (or forward or redirect)
  1298.  ************************************************************************/
  1299. void XferCustomTable(MessHandle origMessH,MessHandle newMessH)
  1300. {
  1301.     short origTable;
  1302.     Boolean isOut;
  1303.     
  1304.     /*
  1305.      * under the old regime, we don't do this step
  1306.      */
  1307.     if (!NewTables) return;
  1308.     
  1309.     origTable = SumOf(origMessH)->tableId;
  1310.  
  1311.     /*
  1312.      * if the original message had the default table, give the default table
  1313.      * to the new message (which has already been done, so return)
  1314.      */
  1315.     if (origTable == DEFAULT_TABLE) return;
  1316.     
  1317.     isOut = (SumOf(origMessH)->flags&FLAG_OUT)!=0;
  1318.     if (origTable == GetRLong(PREF_STRN+(isOut?PREF_OUT_XLATE:PREF_IN_XLATE)))
  1319.         return;
  1320.     
  1321.     /*
  1322.      * if original was outgoing, use same table
  1323.      * also use same table if that table is no table
  1324.      */
  1325.     if (isOut || !origTable)
  1326.         SumOf(newMessH)->tableId = origTable;
  1327.         
  1328.     /*
  1329.      * Otherwise, look for an out table that corresponds to the In table
  1330.      * and use that.
  1331.      */
  1332.     else if (GetResource('taBL',origTable+1))
  1333.         SumOf(newMessH)->tableId = origTable+1;
  1334. }
  1335.